package com.hs.jhzd.controller;


import com.hs.jhzd.entity.*;
import com.hs.jhzd.entity.dto.QuestionnaireDto;
import com.hs.jhzd.entity.dto.QuestionnaireRusult;
import com.hs.jhzd.repository.*;
import com.hs.jhzd.utils.ToolUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Optional;

@Controller
@RequestMapping("/questionnaire")
@Slf4j
public class QuestionnaireController {

    @Value("${jsbh}")
    private String jsbh;
    @Autowired
    QuestionnaireRepository questionnaireRepository;

    @Autowired
    QuestionnaireAnswerRepository questionnaireAnswerRepository;

    @Autowired
    QuestionnaireQuestionRepository questionnaireQuestionRepository;
    @Autowired
    QuestionnaireOptionRepository questionnaireOptionRepository;
    @Autowired
    private PrisonerRepository prisonerRepository;

    public static final String DATE_FORMAT1 = "yyyy-MM-dd HH:mm:ss";

    @RequestMapping("/findAllQuestionnaire")
    @ResponseBody
    public List<Questionnaire> findAllQuestionnaire(String prisonId) {
        if (StringUtils.isBlank(prisonId)) {
            prisonId = "1";
        }
        return questionnaireRepository.findAllByPrisonId(prisonId);
    }

    @RequestMapping("/findQuestionnaireById")
    @ResponseBody
    public Questionnaire findQuestionnaireById(@RequestParam(required = true) String id) {
        return questionnaireRepository.findQuestionnaireById(id);
    }

    @RequestMapping("/save")
    @ResponseBody
    public boolean answer(@RequestParam(required = true) String prisonId,
                          @RequestParam(required = true) String number,
                          @RequestParam(required = true) String questionnaireId,
                          @RequestParam(required = true) String answers) {
        String[] answersArr = answers.split(",");
        if (answersArr != null && answersArr.length > 1) {
            if (answersArr.length != questionnaireQuestionRepository.countQuestionnaireQuestionByQuestionnaireId(questionnaireId)) {
                throw new IllegalArgumentException("答案数量不对");
            }

            Date now = new Date();
            Prisoner prisoner = prisonerRepository.findByRybh(number);

            for (int i = 0; i < answersArr.length; i++) {
                QuestionnaireAnswer answer = new QuestionnaireAnswer();
                answer.setPrisonId(prisonId);
                answer.setName(prisoner.getName());
                answer.setPrisonerNumber(number);
                answer.setQuestionnaireId(questionnaireId);
                answer.setQuestionnaireQuestionIndex(i);
                answer.setAnswer(Integer.parseInt(answersArr[i]));
                answer.setCreateTime(now);
                questionnaireAnswerRepository.save(answer);
            }
        }
        return true;
    }

    /*
    答題记录列表
     */
    @RequestMapping("/recordList")
    @ResponseBody
    public List recordList(String name, String jsbh, @DateTimeFormat(pattern = DATE_FORMAT1) Date startTime,
                           @DateTimeFormat(pattern = DATE_FORMAT1) Date endTime) {
        //创建返回值
        List<List<QuestionnaireRusult>> questionnaireRusultList = new ArrayList<>();
        //查询所有题目
        List<QuestionnaireQuestion> questionAll = questionnaireQuestionRepository.findAll();

        if (StringUtils.isNotBlank(name)) {
            List<Prisoner> prisoners = prisonerRepository.findByName(name);
            for (Prisoner prisoner : prisoners) {
                List<QuestionnaireRusult> one = new ArrayList<>();
                List<QuestionnaireAnswer> questionnaireAnswers = questionnaireAnswerRepository.findByRybhAndJsbhAndSjc(prisoner.getRybh(), jsbh, startTime, endTime);
                for (QuestionnaireAnswer questionnaireAnswer : questionnaireAnswers) {
                    int answerQuestionnaireIndex = questionnaireAnswer.getQuestionnaireQuestionIndex();
                    QuestionnaireQuestion questionnaireQuestion = questionAll.get(answerQuestionnaireIndex);
                    QuestionnaireRusult rusult = new QuestionnaireRusult(questionnaireAnswer, questionnaireQuestion);
                    one.add(rusult);
                }
                questionnaireRusultList.add(one);
            }
        } else {
            //答案列表
            List<QuestionnaireAnswer> questionnaireAnswers = questionnaireAnswerRepository.findByRybhAndJsbhAndSjc(null, jsbh, startTime, endTime);
            List<QuestionnaireRusult> one = new ArrayList<>();
            for (QuestionnaireAnswer questionnaireAnswer : questionnaireAnswers) {
                int answerQuestionnaireIndex = questionnaireAnswer.getQuestionnaireQuestionIndex();
                QuestionnaireQuestion questionnaireQuestion = questionAll.get(answerQuestionnaireIndex);
                QuestionnaireRusult rusult = new QuestionnaireRusult(questionnaireAnswer, questionnaireQuestion);
                one.add(rusult);
            }
            questionnaireRusultList.add(one);
        }
        return questionnaireRusultList;
    }

    /*
       出所评估结果查询返回页面
    */
    @RequestMapping("/admin/main")
    public String shiftMainPage(Model model, String name, String jsbh, @DateTimeFormat(pattern = DATE_FORMAT1) Date startTime,
                                @DateTimeFormat(pattern = DATE_FORMAT1) Date endTime) {
        //创建返回值
        List<List<QuestionnaireRusult>> questionnaireRusultList = new ArrayList<>();
        //查询所有题目
        List<QuestionnaireQuestion> questionAll = questionnaireQuestionRepository.findAll();

        if (StringUtils.isNotBlank(name)) {
            List<Prisoner> prisoners = prisonerRepository.findByName(name);
            for (Prisoner prisoner : prisoners) {
                List<QuestionnaireRusult> one = new ArrayList<>();
                List<QuestionnaireAnswer> questionnaireAnswers = questionnaireAnswerRepository.findByRybhAndJsbhAndSjc(prisoner.getRybh(), jsbh, startTime, endTime);
                for (QuestionnaireAnswer questionnaireAnswer : questionnaireAnswers) {
                    String answerQuestionnaireId = questionnaireAnswer.getQuestionnaireId();
                    for (QuestionnaireQuestion questionnaireQuestion : questionAll) {
                        if (questionnaireQuestion.getQuestionnaireId().equals(answerQuestionnaireId)) {
                            QuestionnaireRusult rusult = new QuestionnaireRusult(questionnaireAnswer, questionnaireQuestion);
                            one.add(rusult);
                        }
                    }
                }
                questionnaireRusultList.add(one);
            }
        } else {
            List<QuestionnaireAnswer> questionnaireAnswers = questionnaireAnswerRepository.findByRybhAndJsbhAndSjc(null, jsbh, startTime, endTime);
            List<QuestionnaireRusult> one = new ArrayList<>();
            for (QuestionnaireAnswer questionnaireAnswer : questionnaireAnswers) {
                String answerQuestionnaireId = questionnaireAnswer.getQuestionnaireId();
                for (QuestionnaireQuestion questionnaireQuestion : questionAll) {
                    if (questionnaireQuestion.getQuestionnaireId().equals(answerQuestionnaireId)) {
                        QuestionnaireRusult rusult = new QuestionnaireRusult(questionnaireAnswer, questionnaireQuestion);
                        one.add(rusult);
                    }
                }
            }
            questionnaireRusultList.add(one);
        }
        model.addAttribute("jsbh", jsbh);
        model.addAttribute("results", questionnaireRusultList);
        return "exit-list";
    }

    //1---------------------------------------------------------------调查类型页面------------------------------------------------------------------------
    @RequestMapping("/creatingQuestionnaire")
    @ResponseBody
    //创建出所问卷调查类型
    public Questionnaire creatingQuestionnaire(String name, String surveyType, @RequestParam(value = "id", required = false) String id) {
        if (StringUtils.isNotEmpty(id)) {
            Optional<Questionnaire> byId = questionnaireRepository.findOneById(id);
            Questionnaire questionnaire = byId.get();
            questionnaire.setName(name);
            questionnaire.setSurveyType(surveyType);
            return questionnaireRepository.save(questionnaire);

        }
        Questionnaire questionnaire = new Questionnaire();
        String oldId = questionnaireRepository.findZybh();
        questionnaire.setId(ToolUtils.CreatePrimaryKey(oldId));
        questionnaire.setName(name);
        questionnaire.setPrisonId(jsbh);
        questionnaire.setSurveyType(surveyType);
        questionnaire.setCreateTime(new Date());
        return questionnaireRepository.save(questionnaire);
    }

    @RequestMapping("/deleteBQuestionnaire")
    @ResponseBody
    //创建出所问卷调查类型
    public Questionnaire deleteQuestionnaire(String id) {
        questionnaireRepository.deleteById(id);
        return null;
    }

    @RequestMapping("/findOneQuestionnaire")
    @ResponseBody
    //创建出所问卷调查类型
    public Questionnaire findOneQuestionnaire(String id) {
        Optional<Questionnaire> byId = questionnaireRepository.findOneById(id);
        return byId.get();
    }

    @RequestMapping("/findListQuestionnaire")
    @ResponseBody
    //查询出所问卷调查类型列表
    public List<QuestionnaireDto> findListQuestionnaire(String jsbh) {
        return questionnaireRepository.findByPrisonId(jsbh);
    }


    @RequestMapping("/admin/main1")
    //返回出所类型页面
    public String editPage(Model model, String jsbh) {
        if (StringUtils.isBlank(jsbh) || StringUtils.equals(jsbh, "null")) {
            return "redirect:/conf/admin/main?jsbh=" + this.jsbh;
        }
        List<QuestionnaireDto> questionnaire = questionnaireRepository.findByPrisonId(jsbh);
        model.addAttribute("jsbh", jsbh);
        model.addAttribute("questionnaire", questionnaire);
        return "exitSurvey";
    }


    //2----------------------------------------------------------------------调查题目-----------------------------------------------------------------------
    @RequestMapping("/creatingTitles")
    @ResponseBody
    //创建出所问卷调查题目
    public QuestionnaireQuestion creatingTitles(String questionnaireId, String question, String content1, String content2, String content3, String content4, String titlesId) {
        if (StringUtils.isNotEmpty(titlesId)) {
            QuestionnaireQuestion questionnaireQuestion = questionnaireQuestionRepository.findOneById(titlesId);
            questionnaireQuestion.setQuestion(question);
            questionnaireQuestion.setQuestionnaireId(questionnaireId);
            questionnaireQuestionRepository.save(questionnaireQuestion);
            List<QuestionnaireOption> options = questionnaireQuestion.getOptions();
            options.get(0).setContent(content1);
            options.get(1).setContent(content2);
            options.get(2).setContent(content3);
            options.get(3).setContent(content4);
            questionnaireOptionRepository.save(options.get(0));
            questionnaireOptionRepository.save(options.get(1));
            questionnaireOptionRepository.save(options.get(2));
            questionnaireOptionRepository.save(options.get(3));
            return questionnaireQuestion;
        }
        QuestionnaireQuestion questionnaire = new QuestionnaireQuestion();
        String oldId = questionnaireQuestionRepository.findZybh();
        questionnaire.setId(ToolUtils.CreatePrimaryKey(oldId));
        questionnaire.setQuestionnaireId(questionnaireId);
        questionnaire.setQuestion(question);
        questionnaire.setCreateTime(new Date());
        QuestionnaireQuestion save = questionnaireQuestionRepository.save(questionnaire);
        if (StringUtils.isNotBlank(content1)) {
            String zybh = questionnaireOptionRepository.findZybh();
            QuestionnaireOption questionnaireOption = new QuestionnaireOption();
            questionnaireOption.setId(ToolUtils.CreatePrimaryKey(zybh));
            questionnaireOption.setOptionIndex(1);
            questionnaireOption.setContent(content1);
            questionnaireOption.setQuestionId(save.getId());
            questionnaireOption.getCreateTime(new Date());
            questionnaireOptionRepository.save(questionnaireOption);

        }
        if (StringUtils.isNotBlank(content2)) {
            String zybh = questionnaireOptionRepository.findZybh();
            QuestionnaireOption questionnaireOption = new QuestionnaireOption();
            questionnaireOption.setId(ToolUtils.CreatePrimaryKey(zybh));
            questionnaireOption.setOptionIndex(2);
            questionnaireOption.setContent(content2);
            questionnaireOption.setQuestionId(save.getId());
            questionnaireOption.getCreateTime(new Date());
            questionnaireOptionRepository.save(questionnaireOption);

        }
        if (StringUtils.isNotBlank(content3)) {
            String zybh = questionnaireOptionRepository.findZybh();
            QuestionnaireOption questionnaireOption = new QuestionnaireOption();
            questionnaireOption.setId(ToolUtils.CreatePrimaryKey(zybh));
            questionnaireOption.setOptionIndex(3);
            questionnaireOption.setContent(content3);
            questionnaireOption.setQuestionId(save.getId());
            questionnaireOption.getCreateTime(new Date());
            questionnaireOptionRepository.save(questionnaireOption);

        }
        if (StringUtils.isNotBlank(content4)) {
            String zybh = questionnaireOptionRepository.findZybh();
            QuestionnaireOption questionnaireOption = new QuestionnaireOption();
            questionnaireOption.setId(ToolUtils.CreatePrimaryKey(zybh));
            questionnaireOption.setOptionIndex(4);
            questionnaireOption.setContent(content4);
            questionnaireOption.setQuestionId(save.getId());
            questionnaireOption.getCreateTime(new Date());
            questionnaireOptionRepository.save(questionnaireOption);
        }



        return questionnaireQuestionRepository.save(questionnaire);
    }

    @RequestMapping("/findOneTitles")
    @ResponseBody
    //创建出所问卷题目类型
    public QuestionnaireQuestion findOneTitles(String titlesId) {
        System.out.println(titlesId);
        return questionnaireQuestionRepository.findOneById(titlesId);
    }


    @RequestMapping("/admin/main2")
    //返回出所测评题目添加页面
    public String exitQuestion(Model model, String jsbh) {
        if (StringUtils.isBlank(jsbh) || StringUtils.equals(jsbh, "null")) {
            return "redirect:/conf/admin/main?jsbh=" + this.jsbh;
        }
        List<QuestionnaireQuestion> questionnaire = questionnaireQuestionRepository.findAll();
        model.addAttribute("jsbh", jsbh);
        model.addAttribute("questionnaireQuestion", questionnaire);
        return "exitQuestion";
    }

    @RequestMapping("/deleteTitles")
    @ResponseBody
    //删除题目
    public void deleteTitles(String titlesId) {
        questionnaireQuestionRepository.deleteById(titlesId);
    }

}